/**
 * 场景模式管理器
 * 提供研究模式、决策模式和监控模式的切换和管理
 */

class SceneManager {
    constructor(options = {}) {

// 使用全局变量导出
window.SceneManager = SceneManager;
        this.options = {
            defaultMode: options.defaultMode || 'decision',
            container: options.container || document.body,
            onModeChange: options.onModeChange || null,
            modeConfigs: options.modeConfigs || this.getDefaultModeConfigs(),
            persistState: options.persistState !== false,
            storageKey: options.storageKey || 'app_scene_mode'
        };

        // 当前模式
        this.currentMode = null;
        
        // 模式状态缓存
        this.modeStates = new Map();
        
        // 初始化
        this.init();
    }

    /**
     * 获取默认模式配置
     */
    getDefaultModeConfigs() {
        return {
            research: {
                name: '研究模式',
                description: '详细数据分析和完整技术指标',
                className: 'mode-research',
                features: ['fullData', 'technicalIndicators', 'fundamentalAnalysis'],
                layout: {
                    showSidebar: true,
                    showDetailedCharts: true,
                    showAllIndicators: true
                }
            },
            decision: {
                name: '决策模式',
                description: '关键信号和行动建议',
                className: 'mode-decision',
                features: ['keySignals', 'actionSuggestions', 'riskAnalysis'],
                layout: {
                    showSidebar: false,
                    showDetailedCharts: false,
                    showAllIndicators: false
                }
            },
            monitor: {
                name: '监控模式',
                description: '实时更新和警报设置',
                className: 'mode-monitor',
                features: ['realTimeUpdates', 'alerts', 'performance'],
                layout: {
                    showSidebar: true,
                    showDetailedCharts: false,
                    showAllIndicators: false
                }
            }
        };
    }

    /**
     * 初始化场景管理器
     */
    init() {
        // 恢复保存的模式
        if (this.options.persistState) {
            const savedMode = localStorage.getItem(this.options.storageKey);
            if (savedMode && this.options.modeConfigs[savedMode]) {
                this.currentMode = savedMode;
            }
        }

        // 如果没有保存的模式，使用默认模式
        if (!this.currentMode) {
            this.currentMode = this.options.defaultMode;
        }

        // 创建模式切换控件
        this.createModeControls();
        
        // 应用初始模式
        this.applyMode(this.currentMode);
    }

    /**
     * 创建模式切换控件
     */
    createModeControls() {
        const controlsContainer = document.createElement('div');
        controlsContainer.className = 'scene-mode-controls';
        controlsContainer.setAttribute('role', 'toolbar');
        controlsContainer.setAttribute('aria-label', '场景模式切换');

        // 创建模式切换按钮
        Object.entries(this.options.modeConfigs).forEach(([mode, config]) => {
            const button = document.createElement('button');
            button.className = 'mode-button';
            button.setAttribute('data-mode', mode);
            button.setAttribute('aria-pressed', mode === this.currentMode);
            button.setAttribute('aria-label', config.description);
            
            button.innerHTML = `
                <span class="mode-icon"></span>
                <span class="mode-name">${config.name}</span>
            `;

            button.addEventListener('click', () => this.switchMode(mode));
            controlsContainer.appendChild(button);
        });

        // 添加到容器
        this.options.container.insertBefore(
            controlsContainer,
            this.options.container.firstChild
        );
    }

    /**
     * 切换场景模式
     * @param {String} mode 目标模式
     */
    switchMode(mode) {
        if (mode === this.currentMode || !this.options.modeConfigs[mode]) {
            return;
        }

        // 保存当前模式状态
        this.saveModeState(this.currentMode);

        // 切换到新模式
        const oldMode = this.currentMode;
        this.currentMode = mode;

        // 应用新模式
        this.applyMode(mode);

        // 更新按钮状态
        this.updateModeButtons();

        // 保存模式选择
        if (this.options.persistState) {
            localStorage.setItem(this.options.storageKey, mode);
        }

        // 触发回调
        if (this.options.onModeChange) {
            this.options.onModeChange(mode, oldMode);
        }
    }

    /**
     * 应用场景模式
     * @param {String} mode 要应用的模式
     */
    applyMode(mode) {
        const config = this.options.modeConfigs[mode];
        if (!config) return;

        // 移除其他模式的类名
        Object.values(this.options.modeConfigs).forEach(modeConfig => {
            this.options.container.classList.remove(modeConfig.className);
        });

        // 添加当前模式的类名
        this.options.container.classList.add(config.className);

        // 应用布局配置
        this.applyLayout(config.layout);

        // 启用特定功能
        this.enableFeatures(config.features);

        // 恢复模式状态
        this.restoreModeState(mode);
    }

    /**
     * 应用布局配置
     * @param {Object} layout 布局配置
     */
    applyLayout(layout) {
        // 侧边栏显示/隐藏
        const sidebar = document.querySelector('.sidebar');
        if (sidebar) {
            sidebar.style.display = layout.showSidebar ? 'block' : 'none';
        }

        // 详细图表显示/隐藏
        const detailedCharts = document.querySelectorAll('.detailed-chart');
        detailedCharts.forEach(chart => {
            chart.style.display = layout.showDetailedCharts ? 'block' : 'none';
        });

        // 技术指标显示/隐藏
        const indicators = document.querySelectorAll('.technical-indicator');
        indicators.forEach(indicator => {
            indicator.style.display = layout.showAllIndicators ? 'block' : 'none';
        });
    }

    /**
     * 启用特定功能
     * @param {Array} features 要启用的功能列表
     */
    enableFeatures(features) {
        // 禁用所有功能
        const allFeatures = new Set();
        Object.values(this.options.modeConfigs).forEach(config => {
            config.features.forEach(feature => allFeatures.add(feature));
        });

        allFeatures.forEach(feature => {
            const elements = document.querySelectorAll(`[data-feature="${feature}"]`);
            elements.forEach(el => {
                el.style.display = 'none';
                el.setAttribute('aria-hidden', 'true');
            });
        });

        // 启用指定功能
        features.forEach(feature => {
            const elements = document.querySelectorAll(`[data-feature="${feature}"]`);
            elements.forEach(el => {
                el.style.display = '';
                el.removeAttribute('aria-hidden');
            });
        });
    }

    /**
     * 保存模式状态
     * @param {String} mode 要保存状态的模式
     */
    saveModeState(mode) {
        const state = {
            scrollPosition: window.scrollY,
            formValues: this.getFormValues(),
            chartStates: this.getChartStates()
        };

        this.modeStates.set(mode, state);
    }

    /**
     * 恢复模式状态
     * @param {String} mode 要恢复状态的模式
     */
    restoreModeState(mode) {
        const state = this.modeStates.get(mode);
        if (!state) return;

        // 恢复滚动位置
        window.scrollTo(0, state.scrollPosition);

        // 恢复表单值
        this.restoreFormValues(state.formValues);

        // 恢复图表状态
        this.restoreChartStates(state.chartStates);
    }

    /**
     * 获取表单值
     * @returns {Object} 表单值对象
     */
    getFormValues() {
        const forms = document.querySelectorAll('form');
        const values = {};

        forms.forEach(form => {
            const formData = new FormData(form);
            values[form.id] = Object.fromEntries(formData.entries());
        });

        return values;
    }

    /**
     * 恢复表单值
     * @param {Object} formValues 表单值对象
     */
    restoreFormValues(formValues) {
        Object.entries(formValues).forEach(([formId, values]) => {
            const form = document.getElementById(formId);
            if (!form) return;

            Object.entries(values).forEach(([name, value]) => {
                const element = form.elements[name];
                if (element) {
                    if (element.type === 'checkbox' || element.type === 'radio') {
                        element.checked = value === 'on';
                    } else {
                        element.value = value;
                    }
                }
            });
        });
    }

    /**
     * 获取图表状态
     * @returns {Object} 图表状态对象
     */
    getChartStates() {
        const charts = document.querySelectorAll('[data-chart]');
        const states = {};

        charts.forEach(chart => {
            const chartId = chart.dataset.chart;
            // 这里需要根据具体的图表库来获取状态
            // 例如：如果使用ECharts
            const chartInstance = echarts.getInstanceByDom(chart);
            if (chartInstance) {
                states[chartId] = chartInstance.getOption();
            }
        });

        return states;
    }

    /**
     * 恢复图表状态
     * @param {Object} chartStates 图表状态对象
     */
    restoreChartStates(chartStates) {
        Object.entries(chartStates).forEach(([chartId, state]) => {
            const chart = document.querySelector(`[data-chart="${chartId}"]`);
            if (!chart) return;

            // 这里需要根据具体的图表库来设置状态
            // 例如：如果使用ECharts
            const chartInstance = echarts.getInstanceByDom(chart);
            if (chartInstance) {
                chartInstance.setOption(state);
            }
        });
    }

    /**
     * 更新模式按钮状态
     */
    updateModeButtons() {
        const buttons = document.querySelectorAll('.mode-button');
        buttons.forEach(button => {
            const mode = button.getAttribute('data-mode');
            button.setAttribute('aria-pressed', mode === this.currentMode);
            button.classList.toggle('active', mode === this.currentMode);
        });
    }

    /**
     * 获取当前模式
     * @returns {String} 当前模式名称
     */
    getCurrentMode() {
        return this.currentMode;
    }

    /**
     * 获取模式配置
     * @param {String} mode 模式名称
     * @returns {Object} 模式配置对象
     */
    getModeConfig(mode) {
        return this.options.modeConfigs[mode];
    }

    /**
     * 销毁场景管理器
     */
    destroy() {
        // 移除模式切换控件
        const controls = document.querySelector('.scene-mode-controls');
        if (controls) {
            controls.remove();
        }

        // 清除所有模式类名
        Object.values(this.options.modeConfigs).forEach(config => {
            this.options.container.classList.remove(config.className);
        });

        // 清除状态缓存
        this.modeStates.clear();

        // 如果不需要持久化，清除存储
        if (this.options.persistState) {
            localStorage.removeItem(this.options.storageKey);
        }
    }
}